{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "Noisy DQN 除了在网络结构上加入了噪声参数外，其余部分和DQN是一样的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "is_executing": true
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class NoisyLinear(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim, std_init=0.4):\n",
    "        super(NoisyLinear, self).__init__()\n",
    "        \n",
    "        self.input_dim  = input_dim\n",
    "        self.output_dim = output_dim\n",
    "        self.std_init     = std_init\n",
    "        \n",
    "        self.weight_mu    = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n",
    "        self.weight_sigma = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n",
    "        self.register_buffer('weight_epsilon', torch.FloatTensor(output_dim, input_dim))\n",
    "        \n",
    "        self.bias_mu    = nn.Parameter(torch.FloatTensor(output_dim))\n",
    "        self.bias_sigma = nn.Parameter(torch.FloatTensor(output_dim))\n",
    "        self.register_buffer('bias_epsilon', torch.FloatTensor(output_dim))\n",
    "        \n",
    "        self.reset_parameters()\n",
    "        self.reset_noise()\n",
    "    \n",
    "    def forward(self, x):\n",
    "        if self.training: \n",
    "            weight = self.weight_mu + self.weight_sigma.mul(self.weight_epsilon)\n",
    "            bias   = self.bias_mu   + self.bias_sigma.mul(self.bias_epsilon)\n",
    "        else:\n",
    "            weight = self.weight_mu\n",
    "            bias   = self.bias_mu\n",
    "        \n",
    "        return F.linear(x, weight, bias)\n",
    "    \n",
    "    def reset_parameters(self):\n",
    "        mu_range = 1 / math.sqrt(self.weight_mu.size(1))\n",
    "        \n",
    "        self.weight_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.weight_sigma.data.fill_(self.std_init / math.sqrt(self.weight_sigma.size(1)))\n",
    "        \n",
    "        self.bias_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.bias_sigma.data.fill_(self.std_init / math.sqrt(self.bias_sigma.size(0)))\n",
    "    \n",
    "    def reset_noise(self):\n",
    "        epsilon_in  = self._scale_noise(self.input_dim)\n",
    "        epsilon_out = self._scale_noise(self.output_dim)\n",
    "        \n",
    "        self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))\n",
    "        self.bias_epsilon.copy_(self._scale_noise(self.output_dim))\n",
    "    \n",
    "    def _scale_noise(self, size):\n",
    "        x = torch.randn(size)\n",
    "        x = x.sign().mul(x.abs().sqrt())\n",
    "        return x\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, input_dim,output_dim,hidden_dim=128):\n",
    "        super(Model, self).__init__()\n",
    "        self.fc1 =  nn.Linear(input_dim, hidden_dim)\n",
    "        self.noisy_fc2 = NoisyLinear(hidden_dim, hidden_dim)\n",
    "        self.noisy_fc3 = NoisyLinear(hidden_dim, output_dim)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.noisy_fc2(x))\n",
    "        x = self.noisy_fc3(x)\n",
    "        return x\n",
    "\n",
    "    def reset_noise(self):\n",
    "        self.noisy_fc2.reset_noise()\n",
    "        self.noisy_fc3.reset_noise()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "同 DQN 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        ''' 清空经验回放\n",
    "        '''\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "除了模型需要重置噪声参数外，其余部分和 DQN 一样。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "class Policy:\n",
    "    def __init__(self,cfg):\n",
    "        self.target_update = cfg.target_update\n",
    "        self.action_dim = cfg.action_dim  \n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.gamma = cfg.gamma # 奖励的折扣因子\n",
    "        # e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end =cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.memory = ReplayBuffer(cfg.memory_capacity)\n",
    "        # 当前网络和目标网络\n",
    "        self.policy_net = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        self.target_net = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        # 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "            target_param.data.copy_(param.data)\n",
    "        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器\n",
    "        self.update_cnt = 0 # 用于延迟更新目标网络的计数\n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon指数衰减\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            with torch.no_grad():\n",
    "                state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "                q_values = self.policy_net(state)\n",
    "                action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim)\n",
    "        return action\n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        q_values = self.policy_net(state)\n",
    "        action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        return action\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 从经验回放中随机采样一个批量的样本\n",
    "        states, actions, rewards, next_states, dones = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        # 将数据转换为tensor\n",
    "        states = torch.tensor(np.array(states), device=self.device, dtype=torch.float) # [batch_size, state_dim]\n",
    "        actions = torch.tensor(actions, device=self.device).unsqueeze(1)  #  [batch_size, 1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1)   # [batch_size, 1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [batch_size, state_dim]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1)  # [batch_size,1]\n",
    "        # 计算当前状态(s_t,a)对应的Q值\n",
    "        q_values = self.policy_net(states).gather(dim=1, index=actions) \n",
    "        # 计算下一时刻的状态(s_t_,a)对应的Q值，注意需要detach()，因为不需要计算梯度\n",
    "        next_q_values_max = self.target_net(next_states).max(1)[0].detach().unsqueeze(1)\n",
    "        # 计算期望的Q值，对于终止状态，此时dones[0]=1, 对应的expected_q_value等于reward\n",
    "        expected_q_values = rewards + self.gamma * next_q_values_max * (1-dones) # [batch_size, 1]\n",
    "         # 计算均方根损失\n",
    "        loss = nn.MSELoss()(q_values, expected_q_values) \n",
    "        # 优化更新模型\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # clip防止梯度爆炸\n",
    "        for param in self.policy_net.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "        self.update_cnt += 1\n",
    "        # 每隔一定步数更新目标网络的参数\n",
    "        if self.update_cnt % self.target_update == 0:\n",
    "            for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "                target_param.data.copy_(param.data)\n",
    "        ## 噪声参数重置\n",
    "        self.policy_net.reset_noise()\n",
    "        self.target_net.reset_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "def train(cfg):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = gym.make(cfg.env_id)\n",
    "    setattr(cfg, \"action_space\", env.action_space)\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "    setattr(cfg, \"action_dim\", env.action_space.n)\n",
    "    policy = Policy(cfg)\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    frames = []\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            policy.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{policy.epsilon:.3f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'NoisyDQN' # 算法名称\n",
    "        self.env_id = 'Acrobot-v1' # 环境id\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.train_eps = 200 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.max_steps = 400 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        self.gamma = 0.95 # 折扣因子\n",
    "        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon\n",
    "        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon\n",
    "        self.epsilon_decay = 4000 # e-greedy策略中epsilon的衰减率\n",
    "        self.memory_capacity = 100000 # 经验回放池的容量\n",
    "        self.hidden_dim = 256 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 64 # 批次大小\n",
    "        self.target_update = 100 # 目标网络的更新频率\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t      NoisyDQN      \t   <class 'str'>    \n",
      "       env_id       \t     Acrobot-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "     train_eps      \t        200         \t   <class 'int'>    \n",
      "      test_eps      \t         20         \t   <class 'int'>    \n",
      "     max_steps      \t        200         \t   <class 'int'>    \n",
      "       gamma        \t        0.95        \t  <class 'float'>   \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t        2000        \t   <class 'int'>    \n",
      "  memory_capacity   \t       100000       \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t         64         \t   <class 'int'>    \n",
      "   target_update    \t        100         \t   <class 'int'>    \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/200，奖励：-200.00，Epislon：0.356\n",
      "回合：20/200，奖励：-200.00，Epislon：0.137\n",
      "回合：30/200，奖励：-200.00，Epislon：0.057\n",
      "回合：40/200，奖励：-200.00，Epislon：0.027\n",
      "回合：50/200，奖励：-200.00，Epislon：0.016\n",
      "回合：60/200，奖励：-161.00，Epislon：0.013\n",
      "回合：70/200，奖励：-158.00，Epislon：0.011\n",
      "回合：80/200，奖励：-192.00，Epislon：0.011\n",
      "回合：90/200，奖励：-153.00，Epislon：0.010\n",
      "回合：100/200，奖励：-181.00，Epislon：0.010\n",
      "回合：110/200，奖励：-99.00，Epislon：0.010\n",
      "回合：120/200，奖励：-191.00，Epislon：0.010\n",
      "回合：130/200，奖励：-174.00，Epislon：0.010\n",
      "回合：140/200，奖励：-118.00，Epislon：0.010\n",
      "回合：150/200，奖励：-174.00，Epislon：0.010\n",
      "回合：160/200，奖励：-154.00，Epislon：0.010\n",
      "回合：170/200，奖励：-200.00，Epislon：0.010\n",
      "回合：180/200，奖励：-200.00，Epislon：0.010\n",
      "回合：190/200，奖励：-200.00，Epislon：0.010\n",
      "回合：200/200，奖励：-200.00，Epislon：0.010\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg)\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (joyrl-book)",
   "language": "python",
   "name": "joyrl-book"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "vscode": {
   "interpreter": {
    "hash": "996e2c1bcfa8ebbd3aba48733c28d7658f0aec7cda7e9a0e5abbef50d3f90575"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
